Las 32 librerías de Python que todo ingeniero de IA debería conocer en 2026, ordenadas por relevancia

Las listas de «librerías imprescindibles para IA» suelen repetir los mismos veinte nombres en el orden de siempre: NumPy, Pandas, Scikit-learn, PyTorch, TensorFlow… Sirven como mapa del aprendizaje automático clásico, pero se quedan cortas para lo que hace hoy un ingeniero de IA en Python, que pasa buena parte del día llamando a modelos de lenguaje, validando sus salidas, sirviendo modelos abiertos, montando recuperación aumentada (RAG) y orquestando agentes.

Este repaso parte de esas veinte clásicas, añade doce que faltaban y las ordena todas por lo útiles que resultan a finales de 2026 para alguien que construye productos con IA. La posición indica lo probable que es que la necesites pronto y dice poco de su calidad. Las versiones que aparecen son las publicadas en PyPI a 13 de noviembre de 2026.

El ranking de un vistazo

Las doce incorporaciones respecto a la lista habitual son los SDK oficiales, Pydantic, vLLM, LangGraph, PEFT/TRL, Datasets, las bases vectoriales, LlamaIndex, LiteLLM, Ollama, ONNX Runtime y Gradio/Streamlit. Al final hay un apartado con otras que no entran en el ranking pero conviene tener localizadas.

1. NumPy

NumPy sigue en lo más alto por una razón práctica: los tensores de PyTorch, los DataFrames de Pandas, los embeddings que devuelve Sentence Transformers o los índices de FAISS acaban hablando su idioma. Entender el broadcasting, los tipos (float32 frente a float64) y la vectorización ahorra muchas horas de depuración cuando las formas no cuadran.

import numpy as np

emb = np.random.default_rng(42).normal(size=(1000, 384)).astype(np.float32)
consulta = emb[0]

# similitud coseno de la consulta contra los 1.000 vectores, sin bucles
similitud = emb @ consulta / (np.linalg.norm(emb, axis=1) * np.linalg.norm(consulta))
print(np.argsort(similitud)[::-1][:5])

Matiz: la rama 2.x cambió reglas de promoción de tipos y eliminó alias antiguos (np.float_, por ejemplo). Si heredas código de NumPy 1.x, revisa los avisos antes de actualizar.

2. PyTorch

PyTorch es el marco de referencia para entrenar y ajustar modelos. Lo usan Transformers, vLLM, TRL, Ultralytics o Sentence Transformers por debajo, así que aunque no escribas bucles de entrenamiento a diario, saber mover tensores entre dispositivos, leer un state_dict o perfilar memoria de GPU marca la diferencia cuando algo falla.

import torch
from torch import nn

device = "cuda" if torch.cuda.is_available() else "cpu"
modelo = nn.Sequential(nn.Linear(20, 64), nn.ReLU(), nn.Linear(64, 2)).to(device)
opt = torch.optim.AdamW(modelo.parameters(), lr=1e-3)

x = torch.randn(256, 20, device=device)
y = torch.randint(0, 2, (256,), device=device)

for _ in range(100):
    perdida = nn.functional.cross_entropy(modelo(x), y)
    opt.zero_grad()
    perdida.backward()
    opt.step()

print(perdida.item())

Cuándo usarla: siempre que vayas a entrenar, ajustar o inspeccionar un modelo de pesos abiertos. torch.compile merece una prueba en cuanto el código funciona, porque a menudo acelera sin cambiar el modelo.

3. Hugging Face Transformers

Transformers es la puerta de entrada a los modelos abiertos del Hub: texto, visión, audio y multimodales con una API común. La versión 5 supuso el mayor cambio en años, ya que Hugging Face dejó de dar soporte a TensorFlow y Flax para centrarse en PyTorch como único backend, además de unificar los tokenizadores y retirar varias API antiguas.

from transformers import pipeline

clasificador = pipeline(
    "sentiment-analysis",
    model="nlptown/bert-base-multilingual-uncased-sentiment",
)
print(clasificador("La documentación es clara y el ejemplo funciona a la primera."))

Matiz: si tienes código con TFAutoModel o FlaxAutoModel, te toca migrar a PyTorch o quedarte fijado en la rama 4.x. Para servir LLM en producción, Transformers es cómodo pero no el más rápido; para eso está vLLM (puesto 9).

4. Pandas

Pandas sigue siendo la herramienta por defecto para explorar datos, limpiar logs de conversaciones, preparar conjuntos de evaluación o cruzar resultados de varios modelos. Pandas 3.0, publicado en enero de 2026, hizo obligatorio el modo Copy-on-Write e introdujo un tipo de texto propio (str) que se infiere por defecto en las columnas de cadenas.

import pandas as pd

df = pd.read_csv("conversaciones.csv", parse_dates=["fecha"])
resumen = (
    df.dropna(subset=["respuesta"])
      .assign(palabras=lambda d: d["respuesta"].str.split().str.len())
      .groupby("modelo")["palabras"]
      .agg(["mean", "median", "count"])
)
print(resumen)

Matiz: el código que comprobaba dtype == object para detectar texto, o que modificaba una vista esperando cambiar el original, se comporta distinto en la 3.x. La recomendación oficial es pasar antes por la 2.3 y limpiar avisos. Para volúmenes grandes, Polars (puesto 22) suele ir bastante más rápido.

5. SDK oficiales de LLM: anthropic y openai

Esta es la gran ausencia de las listas clásicas. Buena parte del trabajo de un ingeniero de IA consiste en llamar a modelos comerciales, y los SDK oficiales son la forma más directa y mejor mantenida de hacerlo: tipos completos, reintentos, streaming, herramientas (tool use), salidas estructuradas y procesamiento por lotes. El paquete anthropic da acceso a los modelos Claude y openai a los de OpenAI, con su API Responses.

from anthropic import Anthropic

cliente = Anthropic()  # lee ANTHROPIC_API_KEY del entorno
msg = cliente.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Resume en tres líneas qué es RAG."}],
)
# la respuesta puede traer varios bloques (razonamiento, texto...): quédate con el texto
print("".join(b.text for b in msg.content if b.type == "text"))

Cuándo usarlos: siempre que trabajes con un proveedor concreto y quieras acceso a todas sus funciones el mismo día que salen. Los marcos de alto nivel (LangChain, LlamaIndex, LiteLLM) añaden comodidad, pero también una capa más que puede ir por detrás de la API real. Los identificadores de modelo cambian a menudo, así que conviene sacarlos de configuración y no dejarlos fijos en el código.

6. Pydantic (con Instructor y Pydantic AI)

Pydantic define y valida estructuras de datos a partir de anotaciones de tipo. En proyectos de IA tiene dos usos que se solapan: validar lo que entra en tu API (FastAPI se apoya en él) y obligar a que lo que sale de un LLM tenga la forma esperada. Los SDK oficiales aceptan modelos de Pydantic para pedir salidas estructuradas:

from typing import Literal
from anthropic import Anthropic
from pydantic import BaseModel

class Incidencia(BaseModel):
    servicio: str
    severidad: Literal["baja", "media", "alta"]
    resumen: str

cliente = Anthropic()
r = cliente.messages.parse(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "El checkout devuelve 500 desde las 10:00 y falla en todos los pagos."}],
    output_format=Incidencia,
)
print(r.parsed_output)

Alrededor de Pydantic han crecido dos librerías que conviene conocer. Instructor (1.17) añade salidas validadas con reintentos automáticos sobre muchos proveedores con una sola llamada (instructor.from_provider("proveedor/modelo")). Pydantic AI, ya en su rama 2, es un marco de agentes tipado: defines un Agent con un output_type y herramientas, y obtienes resultados validados.

7. FastAPI

FastAPI es la forma más habitual de exponer un modelo, un pipeline de RAG o un agente como servicio HTTP. Genera la documentación OpenAPI sola, valida peticiones y respuestas con Pydantic y es asíncrono, lo que encaja bien con llamadas a LLM que tardan segundos.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Peticion(BaseModel):
    texto: str

class Respuesta(BaseModel):
    etiqueta: str
    confianza: float

@app.post("/clasificar", response_model=Respuesta)
async def clasificar(p: Peticion) -> Respuesta:
    # aquí iría la llamada al modelo
    return Respuesta(etiqueta="positivo", confianza=0.93)

Con pip install "fastapi[standard]" se arranca en desarrollo con fastapi dev main.py. Para respuestas largas de un LLM, StreamingResponse permite enviar los tokens según llegan.

8. Scikit-learn

Scikit-learn baja posiciones respecto a las listas clásicas porque el día a día de muchos equipos de IA ya no gira en torno a entrenar regresiones, aunque sigue siendo imprescindible para líneas base, clasificadores ligeros sobre embeddings, métricas, validación cruzada y pipelines de preprocesado.

from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

X, y = load_breast_cancer(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, stratify=y, random_state=0)

modelo = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
modelo.fit(X_tr, y_tr)
print(classification_report(y_te, modelo.predict(X_te)))

Consejo: antes de ajustar un LLM para clasificar texto, prueba una regresión logística sobre embeddings. Muchas veces se queda cerca en precisión por una fracción del coste.

9. vLLM

vLLM es el motor de inferencia más extendido para servir modelos de pesos abiertos (Llama, Qwen, Mistral, Gemma…) en GPU. Su gestión de memoria de la caché KV (PagedAttention) y el batching continuo permiten atender muchas peticiones concurrentes con el mismo hardware. Además levanta un servidor compatible con la API de OpenAI con un solo comando: vllm serve Qwen/Qwen2.5-1.5B-Instruct.

from vllm import LLM, SamplingParams

llm = LLM(model="Qwen/Qwen2.5-1.5B-Instruct")
params = SamplingParams(temperature=0.2, max_tokens=200)
salidas = llm.generate(["Explica qué es la atención en un transformer."], params)
print(salidas[0].outputs[0].text)

Alternativas: SGLang y TGI cubren el mismo hueco; para CPU o portátiles, Ollama y llama.cpp (puesto 20). Si el despliegue va a una nube con GPU, el coste por hora de la instancia pesa tanto como la librería elegida.

10. Sentence Transformers

Sentence Transformers genera embeddings de frases y documentos, la pieza central de la búsqueda semántica y del RAG. También incluye cross-encoders para reordenar resultados (reranking) y, desde la versión 6, soporte para modelos multivector al estilo ColBERT.

from sentence_transformers import SentenceTransformer

modelo = SentenceTransformer("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
frases = ["¿Cómo reinicio el router?", "Pasos para resetear el módem", "Receta de tortilla de patatas"]
emb = modelo.encode(frases)
print(modelo.similarity(emb, emb))

El método model.similarity existe desde la versión 3 y calcula la matriz de similitudes con la función configurada en el modelo (coseno por defecto). En la 6 ya no se puede sustituir asignándole una función propia. Para textos en español, elige un modelo multilingüe; los entrenados solo en inglés dan resultados bastante peores.

11. LangGraph

LangGraph modela un agente como un grafo de nodos que comparten un estado. Su ventaja frente a un bucle libre es el control: decides qué pasos existen, cuándo se repite uno, dónde interviene una persona y cómo se guarda el estado (checkpointers) para reanudar una ejecución.

from typing import TypedDict
from langgraph.graph import END, START, StateGraph

class Estado(TypedDict):
    pregunta: str
    respuesta: str

def responder(estado: Estado) -> dict:
    return {"respuesta": f"Recibido: {estado['pregunta']}"}

grafo = StateGraph(Estado)
grafo.add_node("responder", responder)
grafo.add_edge(START, "responder")
grafo.add_edge("responder", END)

app = grafo.compile()
print(app.invoke({"pregunta": "¿Qué es un checkpointer?"}))

Cuándo usarla: en agentes con varios pasos que tienen que ser auditables y recuperables. Para una llamada con un par de herramientas, el SDK del proveedor o create_agent de LangChain bastan.

12. LangChain

LangChain llegó a la versión 1.0 en octubre de 2025 con un compromiso de no romper la API hasta la 2.0 y una interfaz mucho más reducida. El centro es ahora create_agent, que corre sobre LangGraph y admite middleware para meter lógica antes y después de cada llamada al modelo o a una herramienta. Los modelos se indican como "proveedor:modelo", lo que evita importar una clase distinta por proveedor.

from langchain.agents import create_agent

def tiempo(ciudad: str) -> str:
    """Devuelve el tiempo en una ciudad."""
    return f"En {ciudad} hace sol."

agente = create_agent(
    model="anthropic:claude-opus-5-5",  # requiere langchain-anthropic
    tools=[tiempo],
    system_prompt="Eres un asistente conciso.",
)
r = agente.invoke({"messages": [{"role": "user", "content": "¿Qué tiempo hace en Toledo?"}]})
print(r["messages"][-1].text)

Matiz: muchos tutoriales siguen mostrando cadenas con ChatOpenAI(model="gpt-4.1-mini") y el operador |. Funcionan, pero no son el patrón actual, y el nombre del modelo conviene comprobarlo en la documentación del proveedor antes de copiarlo. El valor real de LangChain está en sus integraciones (cargadores, bases vectoriales, proveedores); si solo usas un proveedor, puede que no lo necesites.

13. PEFT y TRL

Ajustar un modelo de miles de millones de parámetros completo es caro. PEFT implementa técnicas como LoRA, que entrenan solo unas matrices pequeñas añadidas al modelo, y TRL aporta los entrenadores para ajuste supervisado (SFT), preferencias (DPO) y aprendizaje por refuerzo (GRPO, entre otros).

from datasets import load_dataset
from peft import LoraConfig
from trl import SFTConfig, SFTTrainer

dataset = load_dataset("trl-lib/Capybara", split="train")
trainer = SFTTrainer(
    model="Qwen/Qwen2.5-0.5B",
    train_dataset=dataset,
    args=SFTConfig(output_dir="qwen-sft-lora"),
    peft_config=LoraConfig(r=16, lora_alpha=32, target_modules="all-linear"),
)
trainer.train()

Con poca GPU, bitsandbytes (cuantización a 4 y 8 bits, base de QLoRA) y Unsloth (núcleos optimizados para entrenar más rápido y con menos memoria) son los complementos habituales.

14. Hugging Face Datasets

Datasets carga conjuntos del Hub o ficheros locales (CSV, JSON, Parquet) sobre Apache Arrow, con mapeado de memoria y caché, de modo que puedes trabajar con datos más grandes que la RAM. Es lo que esperan como entrada los entrenadores de Transformers y TRL.

from datasets import load_dataset

ds = load_dataset("stanfordnlp/imdb", split="train")
ds = ds.filter(lambda ej: len(ej["text"]) < 2000)
ds = ds.map(lambda ej: {"n_palabras": len(ej["text"].split())})
print(ds)

Su compañera Accelerate se encarga de que el mismo script de entrenamiento corra en una GPU, en varias o en varios nodos sin reescribirlo.

15. FAISS

FAISS, de Meta, busca los vecinos más cercanos entre millones de vectores en memoria, en CPU o GPU. No es una base de datos: no persiste metadatos ni gestiona filtros complejos, pero como motor de búsqueda puro es difícil de batir y muchas bases vectoriales lo usan o se inspiran en él.

import faiss
import numpy as np

d = 384
base = np.random.default_rng(0).random((10_000, d), dtype=np.float32)
faiss.normalize_L2(base)          # con vectores normalizados, producto interno = coseno

indice = faiss.IndexFlatIP(d)
indice.add(base)
distancias, ids = indice.search(base[:3], 5)
print(ids)

El índice plano es exacto. Cuando el volumen crece, los índices aproximados (IndexHNSWFlat, IndexIVFPQ) cambian algo de precisión por mucha velocidad y memoria.

16. Bases de datos vectoriales: Qdrant, Chroma y pgvector

En cuanto un RAG pasa del prototipo necesita persistencia, filtros por metadatos, actualizaciones y, a veces, búsqueda híbrida (vectores más palabras clave). Ahí entran las bases vectoriales. Qdrant es un servidor dedicado con un cliente Python completo; Chroma es la opción más sencilla para empezar en local; y pgvector añade vectores a PostgreSQL, muy práctico si ya tienes los datos ahí.

from qdrant_client import QdrantClient, models

cliente = QdrantClient(":memory:")  # modo local para pruebas
cliente.create_collection(
    "docs",
    vectors_config=models.VectorParams(size=4, distance=models.Distance.COSINE),
)
cliente.upsert("docs", points=[
    models.PointStruct(id=1, vector=[0.1, 0.2, 0.3, 0.4], payload={"titulo": "intro"}),
])
print(cliente.query_points("docs", query=[0.1, 0.2, 0.3, 0.4], limit=1).points)

Elegir entre ellas depende más de la operación que del rendimiento: si el equipo ya administra PostgreSQL, pgvector evita un servicio más que vigilar.

17. LlamaIndex

LlamaIndex está especializado en conectar LLM con documentos propios: cargadores para decenas de formatos, troceado, índices, recuperadores y motores de consulta. Para un RAG sobre PDF, wikis o tickets, llegas antes a algo funcional que montándolo a mano.

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex

docs = SimpleDirectoryReader("./documentos").load_data()
indice = VectorStoreIndex.from_documents(docs)
print(indice.as_query_engine().query("¿Qué dice el contrato sobre la renovación?"))

Ojo: si no configuras nada, usa por defecto modelos de OpenAI para embeddings y respuestas. Ajusta Settings.llm y Settings.embed_model antes de mandar documentos internos a ningún sitio.

18. MLflow

MLflow registra experimentos (parámetros, métricas, artefactos), versiona modelos y, desde la rama 3, se ha volcado en la IA generativa: trazas de llamadas a LLM y agentes, evaluación con jueces y gestión de prompts.

import mlflow

mlflow.set_experiment("clasificador-tickets")
with mlflow.start_run():
    mlflow.log_param("modelo", "logreg")
    mlflow.log_metric("f1", 0.91)

Alternativas: Weights & Biases es la opción alojada más popular para seguir entrenamientos; para observabilidad específica de LLM hay herramientas como Langfuse o LangSmith.

19. LiteLLM

LiteLLM ofrece una única interfaz, al estilo de la API de OpenAI, para más de cien proveedores, y un proxy con claves virtuales, límites de gasto, caché y reintentos entre modelos. Es útil cuando una plataforma interna tiene que repartir tráfico entre varios proveedores.

from litellm import completion

r = completion(
    model="anthropic/claude-opus-5-5",
    messages=[{"role": "user", "content": "Hola"}],
)
print(r.choices[0].message.content)

Matiz de seguridad: el 24 de marzo de 2026 se publicaron en PyPI dos versiones maliciosas (1.82.7 y 1.82.8) que robaban credenciales, tras el robo del token de publicación a través de una acción de CI comprometida. PyPI las retiró en pocas horas. Fija versiones con hash en tus dependencias, algo que vale para cualquier paquete de esta lista.

20. Ollama y llama-cpp-python

Ollama descarga y ejecuta modelos abiertos en local con un comando (ollama pull llama3.2) y expone una API que su cliente Python consume directamente. Por debajo usa el trabajo de llama.cpp, que también tiene sus propios bindings, llama-cpp-python, para quien quiera cargar ficheros GGUF sin servidor intermedio.

import ollama

r = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Explica qué es una cuantización Q4."}],
)
print(r.message.content)

Viene de perlas para desarrollar sin gastar en API, para datos que no pueden salir de la máquina y para pruebas rápidas de modelos pequeños.

21. XGBoost

XGBoost sigue siendo de lo mejor que hay para datos tabulares: riesgo, fraude, previsión de demanda, puntuación de clientes. En ese terreno, un buen gradient boosting suele ganar a una red neuronal y a cualquier LLM.

import xgboost as xgb
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split

X, y = fetch_california_housing(return_X_y=True)
X_tr, X_val, y_tr, y_val = train_test_split(X, y, random_state=0)

modelo = xgb.XGBRegressor(n_estimators=500, learning_rate=0.05, max_depth=6,
                          early_stopping_rounds=50)
modelo.fit(X_tr, y_tr, eval_set=[(X_val, y_val)], verbose=False)
print(modelo.best_iteration)

Combínalo con Optuna (ya en la versión 5) para buscar hiperparámetros y con SHAP para explicar qué variables pesan en cada predicción.

22. Polars

Polars es un motor de DataFrames escrito en Rust, multihilo y con evaluación perezosa: describes la consulta y el optimizador decide cómo ejecutarla. Polars 2.0 ha hecho que la API perezosa use el motor streaming por defecto, lo que permite procesar datos que no caben en memoria.

import polars as pl

resumen = (
    pl.scan_parquet("logs/*.parquet")
      .filter(pl.col("latencia_ms") > 0)
      .group_by("modelo")
      .agg(pl.col("latencia_ms").median().alias("p50"), pl.len().alias("peticiones"))
      .collect()
)
print(resumen)

Matiz: la 2.0 trae una lista larga de cambios incompatibles, entre ellos el orden de filas en algunas operaciones. Si vienes de la 1.x, revisa la guía de migración oficial. DuckDB, que acaba de sacar su versión 2.0, cubre el mismo hueco con SQL y combina bien con ambos.

23. LightGBM

LightGBM, de Microsoft, compite con XGBoost en el mismo terreno. Suele entrenar más rápido en conjuntos grandes y maneja variables categóricas de forma nativa. En la práctica, conviene probar los dos (y CatBoost) y quedarse con el que mejor valide.

import lightgbm as lgb

# mismos X_tr, X_val, y_tr, y_val que en el ejemplo de XGBoost
modelo = lgb.LGBMRegressor(n_estimators=1000, learning_rate=0.05)
modelo.fit(X_tr, y_tr, eval_set=[(X_val, y_val)],
           callbacks=[lgb.early_stopping(50)])

24. OpenCV

OpenCV resuelve el trabajo «de fontanería» con imágenes y vídeo: leer cámaras, redimensionar, recortar, convertir espacios de color, filtrar o dibujar resultados. OpenCV 5, publicado en junio de 2026, reescribió su motor DNN con mejor cobertura de ONNX y eliminó la antigua API en C.

import cv2

img = cv2.imread("pieza.jpg")
gris = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
bordes = cv2.Canny(gris, 100, 200)
cv2.imwrite("bordes.png", bordes)

Ojo con un detalle de siempre: OpenCV carga las imágenes en BGR, no en RGB, y muchos modelos esperan lo segundo.

25. Ultralytics YOLO

Ultralytics empaqueta la familia YOLO para detección, segmentación, pose y clasificación con muy poco código. La generación actual es YOLO26, disponible desde la versión 8.4.0 del paquete (enero de 2026) y pensada para dispositivos de borde.

from ultralytics import YOLO

modelo = YOLO("yolo26n.pt")      # variante nano; también hay s, m, l y x
resultados = modelo("bus.jpg")
resultados[0].show()

Matiz de licencia: el código y los modelos se distribuyen bajo AGPL-3.0, con licencia empresarial aparte. Antes de meterlo en un producto cerrado, revisa qué implica.

26. JAX

JAX combina una API parecida a NumPy con diferenciación automática (grad), compilación con XLA (jit) y vectorización (vmap). Es la base de buena parte de la investigación de Google y brilla en TPU y en entrenamiento a gran escala.

import jax
import jax.numpy as jnp

def perdida(w, x, y):
    return jnp.mean((x @ w - y) ** 2)

grad = jax.jit(jax.grad(perdida))
x, y, w = jnp.ones((32, 3)), jnp.zeros(32), jnp.zeros(3)
print(grad(w, x, y))

Para un ingeniero de producto es menos frecuente que PyTorch; para investigación o si trabajas con TPU, sube muchos puestos.

27. ONNX Runtime

ONNX Runtime ejecuta modelos exportados al formato ONNX en CPU, GPU y aceleradores (CUDA, TensorRT, OpenVINO, DirectML, CoreML) sin arrastrar PyTorch a producción. Es la vía habitual para inferencia ligera en servidores sin GPU, en escritorio o en el navegador.

import numpy as np
import onnxruntime as ort

sesion = ort.InferenceSession("modelo.onnx", providers=["CPUExecutionProvider"])
entrada = sesion.get_inputs()[0].name
salida = sesion.run(None, {entrada: np.random.rand(1, 3, 224, 224).astype(np.float32)})

28. Gradio y Streamlit

Enseñar un modelo a alguien que no programa exige una interfaz. Gradio monta una demo con entradas y salidas en pocas líneas y se integra con Hugging Face Spaces; Streamlit es más adecuado para paneles y herramientas internas con más lógica.

import gradio as gr

def responder(texto):
    return texto.upper()

gr.Interface(fn=responder, inputs="text", outputs="text").launch()

29. spaCy

spaCy sigue siendo la opción sólida para PLN de producción cuando no hace falta un LLM: extracción de entidades, análisis sintáctico, segmentación y reglas, con modelos en español y un rendimiento muy alto en CPU.

import spacy

nlp = spacy.load("es_core_news_sm")  # python -m spacy download es_core_news_sm
doc = nlp("Telefónica presentó sus resultados en Madrid el 30 de octubre.")
print([(e.text, e.label_) for e in doc.ents])

Procesar un millón de documentos con spaCy cuesta minutos y céntimos; con un LLM, bastante más. Para tareas bien definidas sigue siendo una opción muy razonable.

30. Keras 3

Keras 3 ya no depende de TensorFlow: es una API de alto nivel que funciona sobre JAX, PyTorch o TensorFlow. Es cómoda para docencia y prototipos, aunque en proyectos nuevos de IA generativa pesa poco frente a PyTorch con Transformers.

import os
os.environ["KERAS_BACKEND"] = "torch"  # o "jax" / "tensorflow"

import keras

modelo = keras.Sequential([
    keras.Input(shape=(20,)),
    keras.layers.Dense(64, activation="relu"),
    keras.layers.Dense(1, activation="sigmoid"),
])
modelo.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])

Corrección frecuente: en Keras 3, pasar input_shape a la primera capa Dense dentro de un Sequential genera un aviso. Lo recomendado es declarar la entrada con keras.Input(shape=...), como en el ejemplo.

31. TensorFlow

TensorFlow mantiene una base instalada enorme, pero su papel ha cambiado. La versión 2.21, de marzo de 2026, se centró en estabilidad, parches de seguridad y en el paso de LiteRT (el sucesor de TensorFlow Lite) a producción. Transformers ya no lo soporta desde la v5, y el propio Google orienta los proyectos nuevos de IA generativa hacia Keras 3, JAX o PyTorch.

Cuándo usarlo: si mantienes modelos existentes en TensorFlow, si despliegas en móviles y dispositivos con LiteRT o si tu infraestructura gira en torno a TF Serving. Para empezar de cero en 2026, hay mejores opciones.

32. NLTK

NLTK fue durante años la librería de PLN en Python y sigue siendo útil para aprender conceptos (tokenización, stemming, corpus) y para utilidades puntuales. Para producción, spaCy o un modelo de Transformers lo superan con claridad.

import nltk
nltk.download("punkt_tab")

from nltk.tokenize import word_tokenize
print(word_tokenize("No es lo mismo tokenizar que lematizar.", language="spanish"))

El recurso correcto es punkt_tab: desde la versión 3.8.2, NLTK dejó de usar el antiguo punkt basado en pickle por motivos de seguridad, y muchos tutoriales antiguos fallan por eso.

Otras que conviene tener localizadas

• Optuna: optimización de hiperparámetros; la versión 5.0 (septiembre de 2026) cambió la configuración por defecto de su muestreador.
• SHAP: explicabilidad de modelos, sobre todo los de árboles.
• Weights & Biases (wandb): seguimiento de entrenamientos y experimentos en la nube.
• DuckDB: SQL analítico en proceso sobre Parquet, CSV o DataFrames; la 2.0 (octubre de 2026) añade un modo cliente-servidor.
• DSPy: programación de pipelines de LLM con optimización automática de prompts.
• Ray: computación distribuida para procesamiento de datos, entrenamiento e inferencia por lotes.
• Ragas y DeepEval: evaluación de RAG y de aplicaciones con LLM. La librería evaluate de Hugging Face apenas se ha movido en el último año, así que para LLM conviene mirar estas antes.
• Matplotlib y Seaborn: gráficas para análisis y curvas de entrenamiento.

Por dónde empezar

La recomendación habitual (NumPy, Pandas, Scikit-learn, PyTorch, Transformers y FastAPI) sigue siendo buena base, pero le falta la parte de LLM que hoy ocupa buena parte del trabajo. Una ruta razonable en 2026:

• Fundamentos de datos: NumPy y Pandas, y Polars cuando el volumen lo pida.
• Modelos: Scikit-learn para líneas base y métricas; PyTorch y Transformers para entender y ajustar modelos abiertos.
• Aplicaciones con LLM: el SDK oficial de tu proveedor, Pydantic para salidas estructuradas y FastAPI para publicarlo.
• Recuperación: Sentence Transformers para embeddings y FAISS o una base vectorial (pgvector si ya usas PostgreSQL).
• Siguiente nivel: LangGraph cuando haya agentes con varios pasos, vLLM cuando sirvas modelos propios, PEFT/TRL cuando necesites ajustarlos y MLflow para no perder la pista de nada.

El resto se aprende cuando el proyecto lo pide. Visión por computador (OpenCV, Ultralytics), datos tabulares (XGBoost, LightGBM) o investigación (JAX) son especialidades en las que conviene profundizar solo si tu trabajo va por ahí.

Imagen: Pexels / Nemuel Sereti